﻿<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Compilador de Pascal :: PLg 2007-2008 </title>

<link href="style.css" rel="stylesheet" type="text/css" />
<!--[if IE 6]>
  <style>
  /*<![CDATA[*/
#sidebarbottom {background:url('images/sidebarbottom.jpg') no-repeat -3px;}
  /*]]>*/
  </style>
<![endif]-->
</head>

<body>
<div id="wrap">
<div id="topbar">
  
</div>
<div id="header">
<ul id="topmenu">
<li><a href="index.html">Inicio</a></li>
<li class="active"><a href="Lexico.html">L&eacute;xico</a></li>
<li><a href="Sintactico.html">Sint&aacute;ctico</a></li>
<li><a href="tablaDeSimbolos.html">Tabla de símbolos</a></li>
<li><a href="gestorDeErrores.html">Gestor de errores</a></li>
<li><a href="casosDePrueba.html">Casos de Prueba</a></li>
</ul>
</div>
<div id="content">
<div id="mainpage">
<a id="intro" name="intro"></a>
<h2>Introducci&oacute;n</h2>
<p>Para el desarrollo de nuestro analizador l&eacute;xico hemos utilizado la herramienta JFlex (http://jflex.de/). 
M&aacute;s abajo se especifica con m&aacute;s detalle la implementaci&oacute;n con esta herramienta.</p>

<h3>L&eacute;xico</h3>

<p>La secci&oacute;n l&eacute;xico del proyecto especificar&aacute; el dise&ntilde;o e implementaci&oacute;n de las estructuras y codificaciones de los que dispone el analizador para interpretar el c&oacute;digo.</p>
<p>codificaciones de los que dispone el analizador para interpretar el c&oacute;digo. Es la parte del proyecto en la que aparece el scanner y los tokens elegidos. As&iacute; mismo nos servir&aacute; para explicar detenidamente las expresiones regulares deducidas de pascal y las acciones sem&aacute;nticas asociadas.</p>

<p>Tabla de s&iacute;mbolos</p>
<h3>Gestor de errores</h3>

<p>Para la gesti&oacute;n de errores hemos optado por el uso de un ArrayList con objetos de tipo TError que guardan informaci&oacute;n de la fila y la columna donde se produjo el error.</p>

<a id="JFlex" name="JFlex"></a>
<h2>JFLEX</h2>
<p>Para la generaci&oacute;n del aut&oacute;mata de estados del analizador l&eacute;xico hemos utilizado JFlex (http://jflex.de/). Se trata de una potente herramienta, que dadas las expresiones regulares que reconocen los tokens del lenguaje y sus acciones asociadas, generan el aut&oacute;mata reconocedor de forma autom&aacute;tica.</p>

<p>En el c&oacute;digo se incluyen, en el paquete <i>Lexico</i>, el archivo original (Lexico.flex) y el compilado por JFlex, Lexico.java.</p>

<h3>Estructura del archivo .flex</h3>

<ul>
<li>Una cabecera con las inclusiones de c&oacute;digo (<i>imports</i>) necesarias.</li>
<li>Una serie de variables utilizadas por JFlex para insertar las declaraciones, y la definici&oacute;n del Token 
<i>devuelto</i> en el final del fichero.</li>
<li>C&oacute;digo empotrado (que se copia ad hoc al .java) en donde se declara la tabla de s&iacute;mbolos y se define la funci&oacute;n 
<i>creaToken()</i>. Lo que hace esta funci&oacute;n es instanciar un <i>Token</i> con la informaci&oacute;n generada por el aut&oacute;mata:

<p><i>return new Token(type.ordinal(), yyline, yycolumn, atributos);</i></p>
	<ul>
     <li>El ordinal hace referencia al enumerado, que dice de qu&eacute; tipo de <i>Token</i> se trata.</li>		
     <li><i>yyline</i> hace referencia a la l&iacute;nea donde est&aacute; ubicado el <i>Token</i>.</li>
     <li><i>yycolumn</i> hace referencia a la columna donde est&aacute; ubicado el <i>Token</i>.</li>
     <li>atributos es un <i>Object</i> que define los atributos del <i>Token</i>, generados en esta funci&oacute;n a partir del tipo.</li>
	</ul>
</li>
<li>Luego viene el conjunto de expresiones regulares, que sigue un esquema:<i> nombre_expresi&oacute;n = expresi&oacute;n_regular</i> M&aacute;s abajo se explica c&oacute;mo se definen las expresiones regulares.</li>
<li>
Por &uacute;ltimo, se definen las acciones asociadas a los patrones, que bien pueden estar definidos por expresiones regulares en el apartado anterior, o se pueden definir directamente. Aqu&iacute; se utiliza la funci&oacute;n 
<i>creaToken</i> mencionada antes.

<p>Si llega al final y no ha entrado en ninguna de las acciones, entonces se considera que el 
<i>Token</i> es err&oacute;neo y se notifica al gestor de errores.</p>
</li>
</ul>

<h3>Expresiones regulares</h3>
<p>Introducimos aqu&iacute; un peque&ntilde;o resumen de c&oacute;mo se escriben algunas expresiones regulares que hemos usado de JFlex, como referencia para aqu&eacute;llos que no conozcan el lenguaje:</p>

<table>
      <col class="Expresi&oacute;n">
      <col class="Descripci&oacute;n">
    


      <tbody>
	<tr>
	  <th>Expresi&oacute;n</th>
	  <th>Descripci&oacute;n</th>
 	 </tr>


	<tr>	  <td class="Expresi&oacute;n">[A-Z] </td>
		  <td class="Descripci&oacute;n">Conjuntos de caracteres del intervalo </td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">[^c] </td>
		  <td class="Descripci&oacute;n">Conjunto de caracteres que excluye el car&aacute;cter 'c'</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">{n_e1}|{n_e2}</td>
		  <td class="Descripci&oacute;n">e1 OR e2</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">{nombre}</td>
		  <td class="Descripci&oacute;n">Referencia al nombre de una expresi&oacute;n definida</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">(exp)?</td>
		  <td class="Descripci&oacute;n">La expresi&oacute;n exp una sola vez</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">(exp)*</td>
		  <td class="Descripci&oacute;n">La expresi&oacute;n exp cero o m&aacute;s veces</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">(exp)+</td>
		  <td class="Descripci&oacute;n">La expresi&oacute;n exp una o m&aacute;s veces</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">\. \{ \' \</td>
		  <td class="Descripci&oacute;n">'\': car&aacute;cter de escape, representa los caracteres que le siguen.</td>
	</tr>


	<tr>	  <td class="Expresi&oacute;n">\n \r \t</td>
		  <td class="Descripci&oacute;n">Caracteres especiales: nueva l&iacute;nea, retorno, tabulaci&oacute;n</td>
	
	</tr>
      </tbody>
    </table>

<a id="L&eacute;xico" name="L&eacute;xico"></a>
<h2>L&eacute;xico</h2>

<p>Como ya se mencion&oacute; en la introducci&oacute;n, en esta secci&oacute;n de proyecto se observa c&oacute;mo se comporta el analizador l&eacute;xico para gestionar cada entrada del c&oacute;digo.</p>
<p>Podemos distinguir dos partes, la especificaci&oacute;n y la implementaci&oacute;n. En la primera comentaremos c&oacute;mo es la gram&aacute;tica que reconoce el analizador, c&oacute;mo se ha dise&ntilde;ado la estructura interna de los tokens del lenguaje y su codificaci&oacute;n. En la segunda parte, veremos la forma en que hemos plasmado en JAVA toda esta informaci&oacute;n y la interfaz de acceso para el analizador sint&aacute;ctico.</p>

<h3>Especificaci&oacute;n</h3>
<h4>Gram&aacute;tica</h4>
<p>Estudiando el lenguaje pascal, llegamos a ciertas reglas con las que hemos generado una serie de expresiones regulares para reconocer los tokens. A continuaci&oacute;n mostramos dichas expresiones y las acciones sem&aacute;nticas que hemos asociado a dichos patrones.</p>

<b>Expresiones regulares</b><BR><BR>
letra = [A-Za-z] <BR>
digito = [0-9] <BR>
alfanumerico = {letra}|{digito} <BR>
caracter = \'([^'])?\' <BR>
cadena = \'([^'])*\' <BR>
identificador = {letra}({alfanumerico})* <BR>
entero = {digito}+ <BR>
numeroE = \E | \e <BR>
real = {digito}+\.{digito}+({numeroE}{digito}+)? <BR>
llaveIzq = \{ <BR>
llaveDer = \} <BR>
comentarioIni = \(\* <BR>
comentarioFin = \*\) <BR>
todoMenosLlave = [^}] <BR>
todoMenosParen = [^)] <BR>
cuerpoComentario1= {todoMenosLlave}* <BR>
cuerpoComentario2= {todoMenosParen}* <BR>
comentario = {llaveIzq}{cuerpoComentario1}{llaveDer} | {comentarioIni}{cuerpoComentario2}{comentarioFin} <BR>
espacio = [ \n\t\r] <BR><BR>
<i>NOTA: Expresiones codificadas en sint&aacute;xis de JFlex</i><BR><BR>

<p>El aut&oacute;mata que obtenemos por la gram&aacute;tica, obtenido gracias a JFlex minimizado y sin fallos se adjunta a este documento debido a su enorme extensi&oacute;n.</p>
<BR>
<b>Acciones sem&aacute;nticas asociadas a los patrones</b><BR><BR>
"*" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.POR); } <BR>
"+" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.MAS); } <BR>
"-" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.MENOS); } <BR>
"/" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.DIVIDE); } <BR>
";" { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.PUNTOYCOMA); } <BR>
"," { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.COMA); } <BR>
"(" { return creaToken(TipoToken.ABREPAREN, yytext()); } <BR>
")" { return creaToken(TipoToken.CIERRAPAREN, yytext()); } <BR>
"[" { return creaToken(TipoToken.ABRECORCHETE, yytext()); } <BR>
"]" { return creaToken(TipoToken.CIERRACORCHETE, yytext()); } <BR>
"(." { return creaToken(TipoToken.ABRECORCHETE, yytext()); } <BR>
".)" { return creaToken(TipoToken.CIERRACORCHETE, yytext()); } <BR>
"and" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.AND); } <BR>
"or" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.OR); } <BR>
"not" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.NOT); } <BR>
"xor" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.XOR); } <BR>
"shl" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.DESP_IZQ); } <BR>
"shr" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.DESP_DER); } <BR>
"=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.IGUAL); } <BR>
"<" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MENOR); } <BR>
">" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MAYOR); } <BR>
"<=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MENOROIGUAL); } <BR>
">=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MAYOROIGUAL); } <BR>
"!=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.DISTINTO); }<BR>
":" { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.DOSPUNTOS); } <BR>
":=" { return creaToken(TipoToken.OPER_ASIGNACION, yytext()); } <BR>
"." { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.PUNTO); } <BR>
"^" { return creaToken(TipoToken.PUNTERO, yytext()); } <BR>
"#" { return creaToken(TipoToken.ASCII, yytext()); } <BR>
"$" { return creaToken(TipoToken.HEXADECIMAL, yytext()); } <BR>
{identificador} { return creaToken(TipoToken.IDENTIFICADOR, yytext()); } <BR>
{entero} { return creaToken(TipoToken.LITERAL_ENTERO, new Integer(yytext())); } <BR>
{real} { return creaToken(TipoToken.LITERAL_REAL, new Double(yytext()));} <BR>
{caracter} { return creaToken(TipoToken.LITERAL_CARACTER, new Character(yytext().charAt(1)));} <BR>
{cadena} { return creaToken(TipoToken.LITERAL_CADENA, new String(yytext().substring(1,yytext().length()-1)));} <BR>
{comentario} /*En la versi&oacute;n final ignorar&aacute; comentarios */<BR> System.out.println("Comentario reconocido: " + yytext()); } 
{espacio} { /* Ignora espacios. */ } <BR> 
. { System.out.println("Caracter ilegal, '" + yytext() + "' linea: " + yyline + ", columna: " + yychar);<BR><BR>

<i>Nota: expresiones codificadas en sint&aacute;xis de JFlex</i><BR><BR>

<h4>Tokens</h4>
<p>La materia de trabajo esencial para un analizador l&eacute;xico son los tokens, que deben estar bien especificados y con una estructura clara. Cada token de nuestro analizador consta de un tipo y de los atributos asociados a dicho token. Adem&aacute;s incluye la l&iacute;nea y la columna donde se encuentra situado en el c&oacute;digo.</p>
<p>Los tipos de token que pueden darse, responden a una lista concreta que hemos dise&ntilde;ado partiendo del lenguaje Pascal. El scanner se encarga de elegir cual ser&aacute; el tipo de un token recibido. Las directrices proporcionadas a JFlex, condicionadas por la gram&aacute;tica del dise&ntilde;o y sus acciones asociadas obligan a que se encuentre siempre un tipo. En caso de que el token no se asociase a ning&uacute;n patr&oacute;n establecido, ser&iacute;a un error l&eacute;xico.</p>
<p>A continuaci&oacute;n mostramos una tabla orientativa del dise&ntilde;o de los tokens.</p>

<table>
      <col class="Expresi&oacute;n">
      <col class="Descripci&oacute;n">
    


      <tbody>
	<tr>
	  <th>Tipo de Token</th>
	  <th>Codificaci&oacute;n elegida</th>
 	 </tr>


	<tr>	  <td class="Tipo de Token">EOF,</td>
		  <td class="Codificaci&oacute;n elegida"></td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">PAL_RES,</td>
		  <td class="Codificaci&oacute;n elegida">(PAL_RES, [Puntero a tabla]) </td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">IDENTIFICADOR,</td>
		  <td class="Codificaci&oacute;n elegida">(IDENTIFICADOR, [Puntero a tabla])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">PUNTERO,</td>
		  <td class="Codificaci&oacute;n elegida">(IDENTIFICADOR, [Puntero a tabla])</td>
	
	</tr>
	<tr>	  <td class="Tipo de Token">LITERAL_ENTERO,</td>
	
		  <td class="Codificaci&oacute;n elegida">(LITERAL_ENTERO, [valor entero])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">LITERAL_REAL,</td>
		  <td class="Codificaci&oacute;n elegida">(LITERAL_REAL, [valor double])</td>
	
	</tr>
	<tr>	  <td class="Tipo de Token">LITERAL_CARACTER,</td>
	
		  <td class="Codificaci&oacute;n elegida">(LITERAL_CARACTER, [car&aacute;cter])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">LITERAL_CADENA,</td>
		  <td class="Codificaci&oacute;n elegida">(LITERAL_CADENA, [string])</td>
	
	</tr>
	
	<tr>	  <td class="Tipo de Token">OPER_ARIT,</td>
		  <td class="Codificaci&oacute;n elegida">(OPER_ARIT, [tipo enumerado asociado])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">SEPARADOR,</td>
		  <td class="Codificaci&oacute;n elegida">(SEPARADOR, [tipo enumerado asociado])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">ABREPAREN,</td>
		  <td class="Codificaci&oacute;n elegida">(ABREPAREN, [])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">CIERRAPAREN,</td>
		  <td class="Codificaci&oacute;n elegida">(CIERRAPAREN,[])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">ABRECORCHETE,</td>
		  <td class="Codificaci&oacute;n elegida">(ABRECORCHETE, [])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">CIERRACORCHETE,</td>
		  <td class="Codificaci&oacute;n elegida">(CIERRACORCHETE, [])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">OPER_RELACIONAL,</td>
		  <td class="Codificaci&oacute;n elegida">(OPER_RELACIONAL,[ tipo enumerado asociado])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">OPER_ASIGNACION,</td>
		  <td class="Codificaci&oacute;n elegida">(OPER_ASIGNACION, [tipo enumerado asociado])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">OPER_LOGICO,</td>
		  <td class="Codificaci&oacute;n elegida">(OPER_LOGICO, [tipo enumerado asociado])</td>
	</tr>
	
	<tr>      <td class="Tipo de Token">SIMBOLO,</td>
		  <td class="Codificaci&oacute;n elegida">(OPER_ARIT, [tipo enumerado asociado])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">ASCII,</td>
		  <td class="Codificaci&oacute;n elegida">(ASCII , [])</td>
	</tr>
	
	<tr>	  <td class="Tipo de Token">HEXADECIMAL</td>
		  <td class="Codificaci&oacute;n elegida">(OPER_ARIT, [tipo enumerado asociado])</td>
	</tr>



      </tbody>
    </table><BR>
	<i>NOTA: Cabe destacar que cada token lleva adem&aacute;s el numero de fila y columna de su posici&oacute;n en el c&oacute;digo</i><BR><BR>

<p>La interfaz con el analizador sint&aacute;ctico, a nivel del analizador l&eacute;xico, se basar&aacute; &uacute;nicamente en un m&eacute;todo de solicitud de un nuevo token.</p>

<h4>Implementacion</h4>
<p>Se ha decidido implementar el analizador en el lenguaje JAVA. Hemos dise&ntilde;ado una estructura que simplifica el control del c&oacute;digo, permitiendo as&iacute; la actualizaci&oacute;n del analizador con nuevos tipos de token o atributos estos.</p>
<p>La clase token.java, gestiona el objeto Token. Proporcion&aacute;ndole los atributos de los que ya hemos hablado en la especificaci&oacute;n.</p>
<p>La clase principal es lexico.java, donde se empotra el c&oacute;digo recibido de JFlex, generando el scanner. Aqu&iacute; se decide que tipo de token se recibe, se monta en un objeto Token y se procesa. Adem&aacute;s contiene el m&eacute;todo nextToken() gracias al cual el analizador sint&aacute;ctico solicita los nuevos tokens del analizador l&eacute;xico.</p>
<p>Las clases TipoToken.java, TipoOperadoresAritmeticos.java, TipoSeparadores.java, TipoOperadoresRelacionales.java y TipoOperadoresLogicos.java son de tipo enumerado. En ellas se definen todos los tipos considerados por el analizador.</p>

<p>TipoToken.java es la m&aacute;s gen&eacute;rica y las dem&aacute;s profundizan en cada uno de los tipos.</p>

<p>A continuaci&oacute;n mostramos los tipos de token implementados, dentro de cada enumerado. Para informaci&oacute;n m&aacute;s detallada sobre la implementaci&oacute;n, recomendamos consultar el javadoc adjunto.</p>

<p><b>TipoToken: </b> <BR> 
EOF, PAL_RES, IDENTIFICADOR, PUNTERO, LITERAL_ENTERO, LITERAL_REAL, LITERAL_CARACTER, LITERAL_CADENA, OPER_ARIT, SEPARADOR, ABREPAREN, CIERRAPAREN, ABRECORCHETE, CIERRACORCHETE, OPER_RELACIONAL, OPER_ASIGNACION, OPER_LOGICO, SIMBOLO, ASCII, HEXADECIMAL. </p>

<p><b>TipoOperadoresRelacionales: </b> <BR> 
IGUAL, MENOR, MAYOR, MENOROIGUAL, MAYOROIGUAL, DISTINTO.</p>

<p><b>TipoOperadoresAritm&eacute;ticos: </b> <BR> 
MAS, MENOS, POR, DIVIDE.</p>

<p><b>TipoOperadoresL&oacute;gicos: </b> <BR> 
AND, OR, NOT, XOR, DESP_IZQ, DESP_DER.</p>

<p><b>TipoSeparadores: </b> <BR> 
COMA, PUNTOYCOMA, PUNTO, DOSPUNTOS.</p>

</div>



<div id="sidebar">
<div id="sidebarcontents"> 
<ul id="menu">
<li><h2>L&eacute;xico</h2></li>
<li>
   &nbsp;<ul>
    	<li><a href="#intro">Introducci&oacute;n</a></li>
	<li><a href="#JFlex">JFlex</a></li>
	<li><a href="#L&eacute;xico">L&eacute;xico</a></li>
	<li><a href="#Tabla de s&iacute;mbolos">Tabla de s&iacute;mbolos</a></li>
	<li><a href="#Gestor de errores">Gestor de errores</a></li>
	<li><a href="#Casos de prueba">Casos de prueba</a></li>
   </ul>
</li>
</ul>
</div>
  <div id="sidebarbottom"></div>
</div>

<div class="clear"></div>
</div>
<div id="footer">
Compilador de Pascal:: PLg 2007-2008</div>
<div id="credit"><a href="http://www.ramblingsoul.com">CSS Layout</a> by Rambling Soul</div></div>

</body>
</html>